 #pragma once

#include <cstdint>
#include <vector>
#include <string>
#include <memory>
#include <type_traits>

namespace SeanNetwork {

// 序列化器类，提供二进制数据的序列化和反序列化功能
class Serializer {
public:
    // 创建新的序列化缓冲区
    Serializer();
    
    // 从现有数据创建反序列化缓冲区
    Serializer(const uint8_t* data, size_t size);
    Serializer(const std::vector<uint8_t>& data);
    
    ~Serializer();
    
    // 重置序列化器状态
    void Reset();
    
    // 写入基本类型
    void Write(bool value);
    void Write(int8_t value);
    void Write(uint8_t value);
    void Write(int16_t value);
    void Write(uint16_t value);
    void Write(int32_t value);
    void Write(uint32_t value);
    void Write(int64_t value);
    void Write(uint64_t value);
    void Write(float value);
    void Write(double value);
    
    // 写入字符串
    void Write(const std::string& value);
    
    // 写入二进制数据
    void WriteBytes(const uint8_t* data, size_t size);
    void WriteBytes(const std::vector<uint8_t>& data);
    
    // 读取基本类型
    bool ReadBool();
    int8_t ReadInt8();
    uint8_t ReadUInt8();
    int16_t ReadInt16();
    uint16_t ReadUInt16();
    int32_t ReadInt32();
    uint32_t ReadUInt32();
    int64_t ReadInt64();
    uint64_t ReadUInt64();
    float ReadFloat();
    double ReadDouble();
    
    // 读取字符串
    std::string ReadString();
    
    // 读取二进制数据
    std::vector<uint8_t> ReadBytes(size_t size);
    
    // 获取序列化后的数据
    const std::vector<uint8_t>& GetData() const { return m_Buffer; }
    
    // 获取当前读取位置
    size_t GetReadPosition() const { return m_ReadPos; }
    
    // 获取当前写入位置
    size_t GetWritePosition() const { return m_WritePos; }
    
    // 检查是否还有足够的数据可读
    bool CanRead(size_t size) const { return (m_ReadPos + size <= m_Buffer.size()); }
    
    // 是否已读取完所有数据
    bool IsEnd() const { return m_ReadPos >= m_Buffer.size(); }
    
private:
    std::vector<uint8_t> m_Buffer;  // 数据缓冲区
    size_t m_ReadPos;               // 当前读取位置
    size_t m_WritePos;              // 当前写入位置
    
    // 确保缓冲区有足够的空间
    void EnsureSpace(size_t additionalSize);
    
    // 网络字节序与主机字节序转换
    template<typename T>
    T NetworkToHost(T value);
    
    template<typename T>
    T HostToNetwork(T value);
};

// 辅助模板函数，用于序列化复杂对象
template<typename T>
typename std::enable_if<std::is_pod<T>::value, void>::type
Serialize(Serializer& serializer, const T& value) {
    serializer.WriteBytes(reinterpret_cast<const uint8_t*>(&value), sizeof(T));
}

template<typename T>
typename std::enable_if<std::is_pod<T>::value, T>::type
Deserialize(Serializer& serializer) {
    T value;
    auto bytes = serializer.ReadBytes(sizeof(T));
    std::memcpy(&value, bytes.data(), sizeof(T));
    return value;
}

} // namespace SeanNetwork
